const db = wx.cloud.database(); // 初始化云数据库实例
const _ = db.command; // 获取数据库命令操作符
const util = require('../../../utils/util.js'); // 引入工具函数，用于处理日期等功能

Page({
  data: {
    userInfo: null, // 当前登录用户信息
    classList: [], // 教师管理的班级列表
    currentClassId: null, // 当前选中的班级ID
    studentsInClass: [], // 当前班级学生基本信息
    testResults: [],     // 当前班级学生测试结果
    statistics: { total: 0, normal: 0, mild: 0, moderate: 0, severe: 0 }, // 心理状况统计数据
    isLoading: true, // 页面加载状态
    
    // 筛选条件选项
    testTypes: ['全部', 'SAS', 'SDS'], 
    currentTestType: '全部', // 当前选中的测试类型
    timeRangeOptions: ['全部时间', '最近一周', '最近一月', '最近三月'],
    currentTimeRange: '全部时间', // 当前选中的时间范围

    // 风险等级定义及对应的颜色
    warningLevels: {
      normal: { text: '正常', color: '#67C23A' },
      mild: { text: '轻度异常', color: '#E6A23C' },
      moderate: { text: '中度异常', color: '#F56C6C' },
      severe: { text: '重度异常', color: '#E71919' }, // 更强的红色
    }
  },

  onLoad() {
    this.loadUserInfoAndClasses(); // 页面加载时获取用户信息和管理的班级
  },

  // 加载用户信息和管理的班级
  async loadUserInfoAndClasses() {
    this.setData({ isLoading: true }); // 设置加载状态
    const userInfo = wx.getStorageSync('userInfo'); // 从本地存储获取用户信息
    
    // 验证用户是否登录及角色是否为教师
    if (!userInfo || userInfo.role !== 'teacher') {
      wx.showToast({ title: '用户未登录或非辅导员', icon: 'none' });
      this.setData({ isLoading: false });
      return;
    }
    // 确保用户信息包含用于查询的唯一标识符
    if (!userInfo.username) {
      wx.showToast({ title: '用户信息不完整，无法查询', icon: 'none' });
      this.setData({ isLoading: false });
      return;
    }
    this.setData({ userInfo }); // 保存用户信息供其他方法使用

    let managedClassIds = [];
    try {
      // 从云端查询辅导员管理的班级ID列表
      console.log(`查询 users 集合，条件: username=${userInfo.username}, role=teacher`);
      const userRes = await db.collection('users').where({
        username: userInfo.username,
        role: 'teacher'
      }).field({ classes: true }).limit(1).get();

      // 处理查询结果，获取管理的班级ID
      if (userRes.data.length > 0 && userRes.data[0].classes && userRes.data[0].classes.length > 0) {
        managedClassIds = userRes.data[0].classes;
        console.log("从云端 users 集合获取到班级列表:", managedClassIds);

        // 构建用于显示的班级列表
        const classListForDisplay = managedClassIds.map(id => ({
          _id: id,
          // 直接使用ID作为名称，或根据需要调整显示格式
          name: `班级 ${id}` 
        }));
        console.log("构建的用于显示的班级列表:", classListForDisplay);

        // 设置班级列表和当前选中的班级
        this.setData({
          classList: classListForDisplay,
          currentClassId: managedClassIds[0] // 设置第一个班级为当前选中
        });

        // 获取当前选中班级的学生测试结果
        await this.fetchTestResults();

      } else {
        console.log("在云端 users 集合中未找到该用户的 classes 字段，或字段为空");
        this.setData({ classList: [], isLoading: false, currentClassId: null, testResults: [], statistics: { total: 0, normal: 0, mild: 0, moderate: 0, severe: 0 } });
        // return; // 不需要 return，因为后面没有逻辑了
      }

      // 移除查询 classes 集合的步骤
      /*
      console.log("查询 classes 集合，条件: _id in", managedClassIds);
      const classRes = await db.collection('classes').where({
        _id: _.in(managedClassIds)
      }).get();

      if (classRes.data.length > 0) {
        console.log("成功获取到班级信息:", classRes.data);
        this.setData({
          classList: classRes.data,
          currentClassId: classRes.data[0]._id
        });
        await this.fetchTestResults(); // 加载默认班级的测试结果
      } else {
        console.log("根据从云端获取的班级ID未能查询到班级信息");
        this.setData({ classList: [], currentClassId: null, testResults: [], statistics: { total: 0, normal: 0, mild: 0, moderate: 0, severe: 0 } });
      }
      */
    } catch (err) {
      // 处理错误情况
      console.error("从云端获取班级列表或信息失败", err);
      wx.showToast({ title: '加载班级数据失败', icon: 'none' });
      this.setData({ classList: [], currentClassId: null, testResults: [], statistics: { total: 0, normal: 0, mild: 0, moderate: 0, severe: 0 } }); // 出错时清空
    } finally {
      this.setData({ isLoading: false }); // 结束加载状态
    }
  },

  // 获取测试结果
  async fetchTestResults() {
    if (!this.data.currentClassId) return; // 如果没有选中班级，则直接返回
    // 重置测试结果和统计数据
    this.setData({ isLoading: true, testResults: [], statistics: { total: 0, normal: 0, mild: 0, moderate: 0, severe: 0 } });

    try {
      // 1. 获取班级所有学生信息，请求 username 和 dormitory 字段
      const studentRes = await db.collection('users').where({
        role: 'student',
        classes: _.all([this.data.currentClassId]) // 查询班级包含当前班级ID的学生
        // 注意: 如果班级ID存储在 user.class (单个字符串) 而不是 user.classes (数组)
        // 则需要修改查询条件为 class: this.data.currentClassId
      }).field({ _id: true, username: true, dormitory: true }).get(); // 请求 username, dormitory
      
      // 提取学生ID列表和创建学生信息映射
      const studentIds = studentRes.data.map(s => s._id);
      const studentMap = studentRes.data.reduce((map, student) => {
        map[student._id] = student; // 创建学生ID到信息的映射 (包含 username, dormitory)
        return map;
      }, {});

      // 检查是否有学生数据
      if (studentIds.length === 0) {
        this.setData({ isLoading: false });
        return; // 班级无学生
      }
      this.setData({ studentsInClass: studentRes.data }); // 保存学生信息

      // 2. 构建测试结果查询条件
      let query = db.collection('psychological_tests').where({
        userId: _.in(studentIds) // 查询学生ID在列表中的测试记录
      });

      // 添加测试类型筛选条件
      if (this.data.currentTestType !== '全部') {
        query = query.where({ type: this.data.currentTestType });
      }

      // 添加时间范围筛选条件
      const now = new Date();
      let startTime = null;
      switch (this.data.currentTimeRange) {
        case '最近一周':
          startTime = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000); // 计算一周前的时间
          break;
        case '最近一月':
          startTime = new Date(now.getFullYear(), now.getMonth() - 1, now.getDate()); // 计算一个月前的时间
          break;
        case '最近三月':
          startTime = new Date(now.getFullYear(), now.getMonth() - 3, now.getDate()); // 计算三个月前的时间
          break;
      }
      // 如果设置了开始时间，添加到查询条件
      if (startTime) {
        query = query.where({ createTime: _.gte(startTime) });
      }

      // 3. 获取每个学生的最新一条符合条件的测试记录
      //    注意：小程序端无法直接按用户分组取最新一条，标准做法是云函数处理
      //    简化处理：获取所有符合条件的记录，然后在前端处理，取每个用户的最新记录
      const allResultsRes = await query.orderBy('createTime', 'desc').get();
      
      // 处理结果，只保留每个学生的最新一条记录
      const latestResultsMap = {};
      allResultsRes.data.forEach(result => {
        if (!latestResultsMap[result.userId]) {
          latestResultsMap[result.userId] = result;
        }
      });
      
      // 整合学生信息和测试结果
      const finalResults = Object.values(latestResultsMap).map(result => ({
        ...result,
        studentName: studentMap[result.userId]?.username || '未知', // 使用 username
        studentIdNum: studentMap[result.userId]?.dormitory || '未知',  // 使用 dormitory
        testType: result.type || result.testType // 添加映射确保在前端显示 testType (与wxml匹配)
      }));

      // 更新测试结果数据
      this.setData({ testResults: finalResults });
      this.calculateStatistics(finalResults); // 计算统计数据

    } catch (err) {
      console.error("获取测试结果失败", err);
      wx.showToast({ title: '加载测试结果失败', icon: 'none' });
    } finally {
      this.setData({ isLoading: false }); // 结束加载状态
    }
  },

  // 计算统计数据
  calculateStatistics(results) {
    console.log("计算统计数据，测试结果:", results);
    // 初始化统计对象
    const stats = { total: results.length, normal: 0, mild: 0, moderate: 0, severe: 0 };
    // 定义不同测试的等级映射关系
    const levelMap = {
      '正常': 'normal',
      '轻度焦虑': 'mild', '轻度抑郁': 'mild', // 兼容不同测试名称
      '中度焦虑': 'moderate', '中度抑郁': 'moderate',
      '重度焦虑': 'severe', '重度抑郁': 'severe'
    };
    
    // 遍历每条测试结果，计算各等级数量
    results.forEach(result => {
      // 确保level字段值有效
      if (!result.level) {
        console.warn("测试结果缺少level字段:", result);
        stats.normal++; // 默认归为正常
        return;
      }
      
      // 根据等级映射统计数量
      const levelKey = levelMap[result.level] || 'normal'; // 默认归为正常
      if (stats.hasOwnProperty(levelKey)) {
        stats[levelKey]++;
      } else {
        console.warn(`未识别的level值: ${result.level}`);
        stats.normal++; // 未识别的也默认归为正常
      }
    });
    
    console.log("统计结果:", stats);
    this.setData({ statistics: stats }); // 更新统计数据
  },

  // 切换班级
  onClassSelect(e) {
    const classId = e.currentTarget.dataset.id; // 获取选中的班级ID
    if (classId !== this.data.currentClassId) { // 检查是否与当前选中班级不同
      this.setData({ currentClassId: classId }); // 更新当前选中的班级
      this.fetchTestResults(); // 获取新选中班级的测试结果
    }
  },

  // 切换测试类型
  onTestTypeSelect(e) {
    const type = e.currentTarget.dataset.type; // 获取选中的测试类型
    if (type !== this.data.currentTestType) { // 检查是否与当前选中类型不同
      this.setData({ currentTestType: type }); // 更新当前选中的测试类型
      this.fetchTestResults(); // 重新获取测试结果
    }
  },

  // 切换时间范围
  onTimeRangeSelect(e) {
    const range = e.currentTarget.dataset.range; // 获取选中的时间范围
    if (range !== this.data.currentTimeRange) { // 检查是否与当前选中范围不同
      this.setData({ currentTimeRange: range }); // 更新当前选中的时间范围
      this.fetchTestResults(); // 重新获取测试结果
    }
  },

  // 跳转到学生详情
  navigateToStudentDetail(e) {
    const studentDbId = e.currentTarget.dataset.id; // 获取的是测试记录ID
    // 从 event 的 dataset 中获取 userId (即学生在 users 集合的 _id)
    const studentUserId = e.currentTarget.dataset.userid; 

    // 检查是否获取到学生ID
    if (!studentUserId) {
        console.error("未能获取到学生的 userId，无法跳转");
        wx.showToast({ title: '无法获取学生信息', icon: 'none' });
        return;
    }
    
    console.log(`准备跳转到学生详情页, 学生 userId: ${studentUserId}`);
    // 跳转到学生详情页面，传递学生ID参数
    wx.navigateTo({ 
        url: `/pages/teacher/student-detail/index?userId=${studentUserId}` // 传递 userId
    });
  },

  // 导出数据（待实现）
  exportData() {
     wx.showToast({ title: '导出功能待实现', icon: 'none' });
     // 实现导出逻辑，可能需要云函数
  }
}); 